Onek8/LNXSDK
1
0
Fork 0
forked from LeenkxTeam/LNXSDK
Code Pull Requests Activity
Files
bfc4c2644fd2540493f1cb147cbce542101dae07
LNXSDK/Kha/Backends/Kinc-hxcpp/khacpp/include/Dynamic.h

499 lines
22 KiB
C
Raw Normal View History

Update Files
2025-01-22 16:18:30 +01:00
#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
Copy Permalink