499 lines
22 KiB
C++
499 lines
22 KiB
C++
#ifndef HX_DYNAMIC_H
|
|
#define HX_DYNAMIC_H
|
|
|
|
// --- Dynamic ---------------------------------------------------------------
|
|
//
|
|
// The Dynamic class views all classes through the hx::Object interface, and
|
|
// provides generic access to its pointer.
|
|
// It uses dynamic_cast to provide strongly-typed access to the real class.
|
|
|
|
namespace hx { class Interface; }
|
|
|
|
|
|
|
|
class HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic : public hx::ObjectPtr<hx::Object>
|
|
{
|
|
typedef hx::ObjectPtr<hx::Object> super;
|
|
|
|
public:
|
|
|
|
Dynamic() {};
|
|
Dynamic(int inVal);
|
|
Dynamic(short inVal);
|
|
Dynamic(unsigned int inVal);
|
|
Dynamic(unsigned short inVal);
|
|
Dynamic(unsigned char inVal);
|
|
Dynamic(signed char inVal);
|
|
Dynamic(const cpp::CppInt32__ &inVal);
|
|
Dynamic(bool inVal);
|
|
Dynamic(double inVal);
|
|
Dynamic(float inVal);
|
|
Dynamic(cpp::Int64 inVal);
|
|
Dynamic(cpp::UInt64 inVal);
|
|
Dynamic(hx::Object *inObj) : super(inObj) { }
|
|
Dynamic(const String &inString);
|
|
Dynamic(const null &inNull) : super(0) { }
|
|
Dynamic(const Dynamic &inRHS) : super(inRHS.mPtr) { }
|
|
explicit Dynamic(const HX_CHAR *inStr);
|
|
Dynamic(const cpp::Variant &inRHS) : super(inRHS.asDynamic()) { }
|
|
template<typename T>
|
|
Dynamic(const hx::Native<T *> &inInterface):super(inInterface.ptr ? inInterface->__GetRealObject() : (hx::Object *)0 ) { }
|
|
#if !defined(__GNUC__) || (defined(__WORDSIZE) && (__WORDSIZE != 64))
|
|
Dynamic(long inVal);
|
|
Dynamic(unsigned long inVal);
|
|
#endif
|
|
#ifdef __OBJC__
|
|
#ifdef HXCPP_OBJC
|
|
Dynamic(const id inObjc);
|
|
#endif
|
|
#endif
|
|
|
|
template<typename T,typename S>
|
|
explicit Dynamic(const cpp::Struct<T,S> &inRHS) { *this = inRHS; }
|
|
template<typename T>
|
|
explicit Dynamic(const cpp::Pointer<T> &inRHS) { *this = inRHS; }
|
|
|
|
|
|
void Set(bool inVal);
|
|
void Set(int inVal);
|
|
void Set(double inVal);
|
|
void Set(float inVal);
|
|
|
|
|
|
template<typename RESULT> RESULT StaticCast() const;
|
|
|
|
inline operator double () const { return mPtr ? mPtr->__ToDouble() : 0.0; }
|
|
inline operator float () const { return mPtr ? (float)mPtr->__ToDouble() : 0.0f; }
|
|
inline operator int () const { return mPtr ? mPtr->__ToInt() : 0; }
|
|
inline operator unsigned int () const { return mPtr ? mPtr->__ToInt() : 0; }
|
|
inline operator short () const { return mPtr ? mPtr->__ToInt() : 0; }
|
|
inline operator unsigned short () const { return mPtr ? mPtr->__ToInt() : 0; }
|
|
inline operator unsigned char () const { return mPtr ? mPtr->__ToInt() : 0; }
|
|
inline operator char () const { return mPtr ? mPtr->__ToInt() : 0; }
|
|
inline operator signed char () const { return mPtr ? mPtr->__ToInt() : 0; }
|
|
inline operator bool() const { return mPtr && mPtr->__ToInt(); }
|
|
inline operator cpp::Int64() const { return mPtr ? mPtr->__ToInt64() : 0; }
|
|
inline operator cpp::UInt64() const { return mPtr ? mPtr->__ToInt64() : 0; }
|
|
|
|
// Conversion to generic pointer requires you to tag the class with a typedef
|
|
template<typename T>
|
|
inline operator typename hx::Native<T *> () const {
|
|
return hx::Native<T *>(dynamic_cast<T *>(mPtr));
|
|
}
|
|
|
|
|
|
//inline operator cpp::Variant() const { return cpp::Variant(mPtr); }
|
|
#ifdef __OBJC__
|
|
#ifdef HXCPP_OBJC
|
|
#ifdef OBJC_ARC
|
|
inline operator id() const { return mPtr ? (__bridge id)mPtr->__GetHandle() : 0; }
|
|
#else
|
|
inline operator id() const { return mPtr ? (id)mPtr->__GetHandle() : 0; }
|
|
#endif
|
|
#endif
|
|
#endif
|
|
inline bool operator !() const { return !mPtr || !mPtr->__ToInt(); }
|
|
|
|
hx::IndexRef operator[](int inIndex);
|
|
inline Dynamic __get(int inIndex) const { return mPtr->__GetItem(inIndex); }
|
|
|
|
template<typename SOURCE_>
|
|
Dynamic(const hx::ObjectPtr<SOURCE_> &inObjectPtr) :
|
|
hx::ObjectPtr<hx::Object>(inObjectPtr.mPtr) { }
|
|
|
|
Dynamic Default(const Dynamic &inDef) { return mPtr ? *this : inDef; }
|
|
|
|
template<typename RETURN_>
|
|
RETURN_ Cast() const { return RETURN_(*this); }
|
|
|
|
template<typename CLASS_>
|
|
bool IsClass() { return CLASS_(mPtr,false).mPtr; }
|
|
|
|
static void __boot();
|
|
|
|
inline bool IsNumeric() const
|
|
{
|
|
if (!mPtr) return false;
|
|
int t = mPtr->__GetType();
|
|
return t==vtInt || t==vtFloat;
|
|
}
|
|
|
|
inline bool IsBool() const
|
|
{
|
|
if (!mPtr) return false;
|
|
int t = mPtr->__GetType();
|
|
return t==vtBool;
|
|
}
|
|
|
|
|
|
int Compare(const Dynamic &inRHS) const
|
|
{
|
|
if (mPtr==0) return inRHS.mPtr==0 ? 0 : -1;
|
|
if (inRHS.mPtr==0) return -1;
|
|
#if (HXCPP_API_LEVEL>=331)
|
|
return mPtr->__Compare(inRHS.mPtr);
|
|
#else
|
|
return mPtr->__Compare(inRHS.mPtr->__GetRealObject());
|
|
#endif
|
|
}
|
|
|
|
bool operator==(const null &inRHS) const { return mPtr==0; }
|
|
bool operator!=(const null &inRHS) const { return mPtr!=0; }
|
|
|
|
bool operator == (const Dynamic &inRHS) const
|
|
{
|
|
// Comparing pointers fails in the case on Nan==Nan
|
|
//if (mPtr==inRHS.mPtr) return true;
|
|
if (!mPtr && !inRHS.mPtr) return true;
|
|
if (!mPtr || !inRHS.mPtr) return false;
|
|
#if (HXCPP_API_LEVEL>=331)
|
|
return mPtr->__Compare(inRHS.mPtr)==0;
|
|
#else
|
|
return mPtr->__Compare(inRHS.mPtr->__GetRealObject())==0;
|
|
#endif
|
|
}
|
|
|
|
bool operator != (const Dynamic &inRHS) const
|
|
{
|
|
// Comparing pointers fails in the case on Nan==Nan
|
|
//if (mPtr==inRHS.mPtr) return true;
|
|
if (!mPtr && !inRHS.mPtr) return false;
|
|
if (!mPtr || !inRHS.mPtr) return true;
|
|
#if (HXCPP_API_LEVEL>=331)
|
|
return mPtr->__Compare(inRHS.mPtr)!=0;
|
|
#else
|
|
return mPtr->__Compare(inRHS.mPtr->__GetRealObject())!=0;
|
|
#endif
|
|
}
|
|
|
|
|
|
bool operator == (const cpp::Variant &inRHS) const { return (*this) == Dynamic(inRHS); }
|
|
bool operator != (const cpp::Variant &inRHS) const { return (*this) != Dynamic(inRHS); }
|
|
|
|
|
|
#define DYNAMIC_COMPARE_OP( op ) \
|
|
bool operator op (const String &inRHS) const { return mPtr && ((String)(*this) op inRHS); } \
|
|
bool operator op (double inRHS) const { return IsNumeric() && ((double)(*this) op inRHS); } \
|
|
bool operator op (cpp::Int64 inRHS) const { return IsNumeric() && ((cpp::Int64)(*this) op inRHS); } \
|
|
bool operator op (cpp::UInt64 inRHS) const { return IsNumeric() && ((cpp::Int64)(*this) op inRHS); } \
|
|
bool operator op (float inRHS) const { return IsNumeric() && ((double)(*this) op inRHS); } \
|
|
bool operator op (int inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
|
|
bool operator op (unsigned int inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
|
|
bool operator op (short inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
|
|
bool operator op (unsigned short inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
|
|
bool operator op (signed char inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
|
|
bool operator op (unsigned char inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
|
|
bool operator op (bool inRHS) const { return IsBool() && ((double)(*this) op (double)inRHS); } \
|
|
|
|
bool operator != (const String &inRHS) const { return !mPtr || ((String)(*this) != inRHS); }
|
|
bool operator != (double inRHS) const { return !IsNumeric() || ((double)(*this) != inRHS); }
|
|
bool operator != (cpp::Int64 inRHS) const { return !IsNumeric() || ((cpp::Int64)(*this) != inRHS); }
|
|
bool operator != (cpp::UInt64 inRHS) const { return !IsNumeric() || ((cpp::Int64)(*this) != inRHS); }
|
|
bool operator != (float inRHS) const { return !IsNumeric() || ((double)(*this) != inRHS); }
|
|
bool operator != (int inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
|
|
bool operator != (unsigned int inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
|
|
bool operator != (short inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
|
|
bool operator != (unsigned short inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
|
|
bool operator != (signed char inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
|
|
bool operator != (unsigned char inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
|
|
bool operator != (bool inRHS) const { return !IsBool() || ((double)(*this) != (double)inRHS); }
|
|
|
|
|
|
|
|
#define DYNAMIC_COMPARE_OP_ALL( op ) \
|
|
bool operator op (const Dynamic &inRHS) const { return mPtr && (Compare(inRHS) op 0); } \
|
|
bool operator op (const cpp::Variant &inRHS) const { return *this op Dynamic(inRHS); } \
|
|
DYNAMIC_COMPARE_OP(op)
|
|
|
|
|
|
DYNAMIC_COMPARE_OP( == )
|
|
DYNAMIC_COMPARE_OP_ALL( < )
|
|
DYNAMIC_COMPARE_OP_ALL( <= )
|
|
DYNAMIC_COMPARE_OP_ALL( >= )
|
|
DYNAMIC_COMPARE_OP_ALL( > )
|
|
|
|
template<typename T_>
|
|
bool operator==(const hx::ObjectPtr<T_> &inRHS) const
|
|
{
|
|
if (mPtr==inRHS.mPtr) return true;
|
|
if (!mPtr || !inRHS.mPtr) return false;
|
|
#if (HXCPP_API_LEVEL>=331)
|
|
return mPtr == inRHS.mPtr;
|
|
#else
|
|
return mPtr->__GetRealObject() == inRHS.mPtr->__GetRealObject();
|
|
#endif
|
|
}
|
|
|
|
template<typename T_>
|
|
bool operator!=(const hx::ObjectPtr<T_> &inRHS) const
|
|
{
|
|
if (mPtr==inRHS.mPtr) return false;
|
|
if (!mPtr || !inRHS.mPtr) return true;
|
|
#if (HXCPP_API_LEVEL>=331)
|
|
return mPtr != inRHS.mPtr;
|
|
#else
|
|
return mPtr->__GetRealObject() != inRHS.mPtr->__GetRealObject();
|
|
#endif
|
|
}
|
|
|
|
|
|
// Operator + is different, since it must consider strings too...
|
|
Dynamic operator+(const Dynamic &inRHS) const;
|
|
inline String operator+(const String &s) const;
|
|
|
|
Dynamic operator+(const cpp::UInt64 &i) const;
|
|
Dynamic operator+(const cpp::Int64 &i) const;
|
|
Dynamic operator+(const int &i) const;
|
|
Dynamic operator+(const unsigned int &i) const;
|
|
Dynamic operator+(const short &i) const;
|
|
Dynamic operator+(const unsigned short &i) const;
|
|
Dynamic operator+(const signed char &i) const;
|
|
Dynamic operator+(const unsigned char &i) const;
|
|
Dynamic operator+(const double &d) const;
|
|
Dynamic operator+(const float &d) const;
|
|
Dynamic operator+(const cpp::Variant &d) const;
|
|
|
|
double operator%(const Dynamic &inRHS) const;
|
|
double operator-() const { return mPtr ? - mPtr->__ToDouble() : 0.0; }
|
|
double operator++() { double val = mPtr->__ToDouble() + 1; *this = val; return val; }
|
|
double operator++(int) {double val = mPtr->__ToDouble(); *this = val+1; return val; }
|
|
double operator--() { double val = mPtr->__ToDouble() - 1; *this = val; return val; }
|
|
double operator--(int) {double val = mPtr->__ToDouble(); *this = val-1; return val; }
|
|
|
|
|
|
double operator / (const cpp::Variant &inRHS) const { return (double)(*this) / (double)inRHS; } \
|
|
double operator / (const Dynamic &inRHS) const { return (double)(*this) / (double)inRHS; } \
|
|
double operator / (const double &inRHS) const { return (double)(*this) / (double)inRHS; } \
|
|
double operator / (const float &inRHS) const { return (double)(*this) / (double)inRHS; } \
|
|
double operator / (const int &inRHS) const { return (double)(*this) / (double)inRHS; }
|
|
|
|
#define DYNAMIC_ARITH( op ) \
|
|
Dynamic operator op (const cpp::Variant &inRHS) const \
|
|
{ return mPtr->__GetType()==vtInt && inRHS.isInt() ? \
|
|
Dynamic((int)(*this) op (int)inRHS) : \
|
|
Dynamic( (double)(*this) op (double)inRHS); } \
|
|
Dynamic operator op (const Dynamic &inRHS) const \
|
|
{ return mPtr->__GetType()==vtInt && inRHS.mPtr->__GetType()==vtInt ? \
|
|
Dynamic((int)(*this) op (int)inRHS) : \
|
|
Dynamic( (double)(*this) op (double)inRHS); } \
|
|
double operator op (const double &inRHS) const { return (double)(*this) op (double)inRHS; } \
|
|
double operator op (const float &inRHS) const { return (double)(*this) op (double)inRHS; } \
|
|
Dynamic operator op (const int &inRHS) const \
|
|
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
|
|
Dynamic operator op (const unsigned int &inRHS) const \
|
|
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
|
|
Dynamic operator op (const short &inRHS) const \
|
|
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
|
|
Dynamic operator op (const unsigned short &inRHS) const \
|
|
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
|
|
Dynamic operator op (const signed char &inRHS) const \
|
|
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
|
|
Dynamic operator op (const unsigned char &inRHS) const \
|
|
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
|
|
Dynamic operator op (const cpp::Int64 &inRHS) const \
|
|
{ return Dynamic((double)(*this) op inRHS); } \
|
|
Dynamic operator op (const cpp::UInt64 &inRHS) const \
|
|
{ return Dynamic((double)(*this) op inRHS); } \
|
|
|
|
DYNAMIC_ARITH( - )
|
|
DYNAMIC_ARITH( * )
|
|
|
|
static void ThrowBadFunctionError();
|
|
inline void CheckFPtr() { if (!mPtr) ThrowBadFunctionError(); }
|
|
|
|
inline ::Dynamic operator()() { CheckFPtr(); return mPtr->__run(); }
|
|
inline ::Dynamic operator()(const Dynamic &inArg0) { CheckFPtr(); return mPtr->__run(inArg0); }
|
|
inline ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1) { CheckFPtr(); return mPtr->__run(inArg0,inArg1); }
|
|
inline ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2) { CheckFPtr(); return mPtr->__run(inArg0,inArg1,inArg2); }
|
|
inline ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3) { CheckFPtr(); return mPtr->__run(inArg0,inArg1,inArg2,inArg3); }
|
|
inline ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4) { CheckFPtr(); return mPtr->__run(inArg0,inArg1,inArg2,inArg3,inArg4); }
|
|
|
|
HX_DECLARE_DYNAMIC_FUNCTIONS;
|
|
|
|
|
|
typedef const Dynamic &D;
|
|
};
|
|
|
|
|
|
|
|
namespace hx
|
|
{
|
|
|
|
inline hx::Object *DynamicPtr(Dynamic inVal) { return inVal.mPtr; }
|
|
|
|
typedef Dynamic (*MemberFunction0)(hx::Object *inObj);
|
|
typedef Dynamic (*MemberFunction1)(hx::Object *inObj,const Dynamic &inArg0);
|
|
typedef Dynamic (*MemberFunction2)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1);
|
|
typedef Dynamic (*MemberFunction3)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2);
|
|
typedef Dynamic (*MemberFunction4)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3);
|
|
typedef Dynamic (*MemberFunction5)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4);
|
|
typedef Dynamic (*MemberFunctionVar)(hx::Object *inObj,const Array<Dynamic> &inArgs);
|
|
|
|
typedef Dynamic (*StaticFunction0)();
|
|
typedef Dynamic (*StaticFunction1)(const Dynamic &inArg0);
|
|
typedef Dynamic (*StaticFunction2)(const Dynamic &inArg0,const Dynamic &inArg1);
|
|
typedef Dynamic (*StaticFunction3)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2);
|
|
typedef Dynamic (*StaticFunction4)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3);
|
|
typedef Dynamic (*StaticFunction5)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4);
|
|
typedef Dynamic (*StaticFunction6)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5);
|
|
typedef Dynamic (*StaticFunctionVar)(const Array<Dynamic> &inArgs);
|
|
|
|
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateMemberFunction0(const char *,hx::Object *, MemberFunction0);
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateMemberFunction1(const char *,hx::Object *, MemberFunction1);
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateMemberFunction2(const char *,hx::Object *, MemberFunction2);
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateMemberFunction3(const char *,hx::Object *, MemberFunction3);
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateMemberFunction4(const char *,hx::Object *, MemberFunction4);
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateMemberFunction5(const char *,hx::Object *, MemberFunction5);
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateMemberFunctionVar(const char *,hx::Object *, MemberFunctionVar,int inN);
|
|
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateStaticFunction0(const char *,StaticFunction0);
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateStaticFunction1(const char *,StaticFunction1);
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateStaticFunction2(const char *,StaticFunction2);
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateStaticFunction3(const char *,StaticFunction3);
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateStaticFunction4(const char *,StaticFunction4);
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateStaticFunction5(const char *,StaticFunction5);
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateStaticFunction6(const char *,StaticFunction6);
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
Dynamic CreateStaticFunctionVar(const char *,StaticFunctionVar,int inN);
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
template<>
|
|
inline int Dynamic::Cast<int>() const { return mPtr ? mPtr->__ToInt() : 0; }
|
|
template<>
|
|
inline bool Dynamic::Cast<bool>() const { return mPtr ? mPtr->__ToInt() : 0; }
|
|
template<>
|
|
inline double Dynamic::Cast<double>() const { return mPtr ? mPtr->__ToDouble() : 0; }
|
|
template<>
|
|
inline float Dynamic::Cast<float>() const { return mPtr ? mPtr->__ToDouble() : 0; }
|
|
template<>
|
|
inline String Dynamic::Cast<String>() const { return mPtr ? mPtr->toString() : String(null()); }
|
|
|
|
|
|
|
|
//
|
|
// Gets the class definition that relates to a specific type.
|
|
// Most classes have their own class data, by the standard types (non-classes)
|
|
// use the template traits to get the class
|
|
|
|
namespace hx
|
|
{
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetIntClass();
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetFloatClass();
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetBoolClass();
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetVoidClass();
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetStringClass();
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetInt64Class();
|
|
}
|
|
|
|
template<>
|
|
inline bool Dynamic::IsClass<int>() { return mPtr && mPtr->__GetClass()==hx::GetIntClass(); }
|
|
template<>
|
|
inline bool Dynamic::IsClass<double>() { return mPtr &&
|
|
( mPtr->__GetClass()==hx::GetIntClass() || mPtr->__GetClass()==hx::GetFloatClass()) ; }
|
|
template<>
|
|
inline bool Dynamic::IsClass<float>() { return mPtr && mPtr->__GetClass()==hx::GetFloatClass(); }
|
|
template<>
|
|
inline bool Dynamic::IsClass<bool>() { return mPtr && mPtr->__GetClass()==hx::GetBoolClass(); }
|
|
template<>
|
|
inline bool Dynamic::IsClass<null>() { return !mPtr; }
|
|
template<>
|
|
inline bool Dynamic::IsClass<String>() { return mPtr && mPtr->__GetClass()==hx::GetStringClass(); }
|
|
template<>
|
|
inline bool Dynamic::IsClass<Dynamic>() { return true; }
|
|
template<>
|
|
inline bool Dynamic::IsClass< ::cpp::Int64>() { return mPtr && mPtr->__GetClass()==hx::GetInt64Class(); }
|
|
|
|
inline String Dynamic::operator+(const String &s) const { return Cast<String>() + s; }
|
|
|
|
#define HX_DYNAMIC_OP_ISEQ(T) \
|
|
inline bool operator == (const T &inLHS,const Dynamic &inRHS) { return inRHS==inLHS; } \
|
|
inline bool operator != (const T &inLHS,const Dynamic &inRHS) { return inRHS!=inLHS; }
|
|
|
|
HX_DYNAMIC_OP_ISEQ(String)
|
|
HX_DYNAMIC_OP_ISEQ(double)
|
|
HX_DYNAMIC_OP_ISEQ(float)
|
|
HX_DYNAMIC_OP_ISEQ(int)
|
|
HX_DYNAMIC_OP_ISEQ(bool)
|
|
|
|
inline bool operator < (bool inLHS,const Dynamic &inRHS) { return false; }
|
|
inline bool operator <= (bool inLHS,const Dynamic &inRHS) { return false; }
|
|
inline bool operator >= (bool inLHS,const Dynamic &inRHS) { return false; }
|
|
inline bool operator > (bool inLHS,const Dynamic &inRHS) { return false; }
|
|
|
|
#if defined(HX_WINRT) && defined(__cplusplus_winrt)
|
|
// Try to avoid the compiler using injected Box::operator int and Dynamic(null) when doing ==
|
|
template<typename T>
|
|
bool operator==(Platform::Box<T> ^inPtr, nullptr_t)
|
|
{
|
|
void* ptr = (void*) reinterpret_cast<void*>(inPtr);
|
|
return ptr==nullptr;
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
#define COMPARE_DYNAMIC_OP( op ) \
|
|
inline bool operator op (double inLHS,const ::Dynamic &inRHS) \
|
|
{ return inRHS.IsNumeric() && (inLHS op (double)inRHS); } \
|
|
inline bool operator op (float inLHS,const ::Dynamic &inRHS) \
|
|
{ return inRHS.IsNumeric() && ((double)inLHS op (double)inRHS); } \
|
|
inline bool operator op (int inLHS,const ::Dynamic &inRHS) \
|
|
{ return inRHS.IsNumeric() && (inLHS op (double)inRHS); }
|
|
|
|
COMPARE_DYNAMIC_OP( < )
|
|
COMPARE_DYNAMIC_OP( <= )
|
|
COMPARE_DYNAMIC_OP( >= )
|
|
COMPARE_DYNAMIC_OP( > )
|
|
|
|
|
|
#define ARITH_DYNAMIC( op ) \
|
|
inline double operator op (const cpp::Int64 &inLHS,const Dynamic &inRHS) { return inLHS op (cpp::Int64)inRHS;} \
|
|
inline double operator op (const cpp::UInt64 &inLHS,const Dynamic &inRHS) { return inLHS op (cpp::UInt64)inRHS;} \
|
|
inline double operator op (const double &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS;} \
|
|
inline double operator op (const float &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS;} \
|
|
inline double operator op (const int &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
|
|
inline double operator op (const unsigned int &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
|
|
inline double operator op (const short &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
|
|
inline double operator op (const unsigned short &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
|
|
inline double operator op (const signed char &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
|
|
inline double operator op (const unsigned char &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
|
|
|
|
ARITH_DYNAMIC( - )
|
|
ARITH_DYNAMIC( + )
|
|
ARITH_DYNAMIC( / )
|
|
ARITH_DYNAMIC( * )
|
|
|
|
double operator%(const int &inLHS,const Dynamic &inRHS);
|
|
double operator%(const double &inLHS,const Dynamic &inRHS);
|
|
double operator%(const float &inLHS,const Dynamic &inRHS);
|
|
|
|
template<typename T,typename H> String::String(const cpp::Struct<T,H> &inRHS) { *this = (String)inRHS; }
|
|
template<typename OBJ> String::String(const hx::ObjectPtr<OBJ> &inRHS) { *this = Dynamic(inRHS); }
|
|
|
|
|
|
|
|
#endif
|