#ifndef CPP_POINTER_H
#define CPP_POINTER_H
namespace cpp
{
struct AutoCast
{
void *value;
explicit inline AutoCast(void *inValue) : value(inValue) { }
};
struct RawAutoCast
{
void *value;
explicit inline RawAutoCast(void *inValue) : value(inValue) { }
template<typename T>
operator T*() const { return (T*)value; }
};
Dynamic CreateDynamicPointer(void *inValue);
enum DynamicHandlerOp
{
dhoGetClassName,
dhoToString,
dhoFromDynamic,
dhoToDynamic,
dhoIs,
};
typedef void (*DynamicHandlerFunc)(DynamicHandlerOp op, void *ioValue, int inSize, void *outResult);
Dynamic CreateDynamicStruct(const void *inValue, int inSize, DynamicHandlerFunc inFunc);
template<typename T> class Reference;
struct StructHandlerDynamicParams
{
StructHandlerDynamicParams(hx::Object *data,const char *inName) :
outProcessed(false), inName(inName), inData(data) { }
bool outProcessed;
hx::Object *inData;
const char *inName;
};
class DefaultStructHandler
{
public:
static inline const char *getName() { return "unknown"; }
static inline String toString( const void *inValue ) { return HX_CSTRING("Struct"); }
static inline void handler(DynamicHandlerOp op, void *ioValue, int inSize, void *outResult)
{
if (op==dhoToString)
*(String *)outResult = toString(ioValue);
else if (op==dhoGetClassName)
*(const char **)outResult = getName();
else if (op==dhoToDynamic)
{
// Handle outsize..
*(hx::Object **)outResult = 0;
}
else if (op==dhoFromDynamic)
{
StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
hx::Object *ptr= params->inData;
void *data = (void *)ptr->__GetHandle();
int len = ptr->__length();
if (data && len>=inSize && ptr->__CStr()==params->inName)
{
memcpy(ioValue,data,inSize);
params->outProcessed = true;
}
}
else if (op==dhoIs)
{
StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
hx::Object *ptr= params->inData;
void *data = (void *)ptr->__GetHandle();
int len = ptr->__length();
params->outProcessed = data && len>=inSize && ptr->__CStr()==params->inName;
}
}
};
class EnumHandler
{
public:
static inline const char *getName() { return "enum"; }
static inline String toString( const void *inValue ) {
int val = inValue ? *(int *)inValue : 0;
return HX_CSTRING("enum(") + String(val) + HX_CSTRING(")");
}
static inline void handler(DynamicHandlerOp op, void *ioValue, int inSize, void *outResult)
{
if (op==dhoToString)
*(String *)outResult = toString(ioValue);
else if (op==dhoGetClassName)
*(const char **)outResult = getName();
else if (op==dhoFromDynamic)
{
StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
if (params->inData->__GetType()==vtInt)
{
*(int *)ioValue = params->inData->__ToInt();
params->outProcessed = true;
}
else
DefaultStructHandler::handler(op,ioValue, inSize, outResult);
}
else
DefaultStructHandler::handler(op,ioValue, inSize, outResult);
}
};
template<typename T, typename HANDLER = DefaultStructHandler >
class Struct
{
public:
T value;
// This allows 'StaticCast' to be used from arrays
typedef Dynamic Ptr;
inline Struct( ) { }
inline Struct( const T &inRHS ) : value(inRHS) { }
inline Struct( const null &) { value = T(); }
inline Struct( const Reference<T> &);
inline Struct( const Dynamic &inRHS) { fromDynamic(inRHS.mPtr); }
inline Struct<T,HANDLER> &operator=( const T &inRHS ) { value = inRHS; return *this; }
inline Struct<T,HANDLER> &operator=( const null & ) { value = T(); return *this; }
inline Struct<T,HANDLER> &operator=( const Dynamic &inRHS ) { return *this = Struct<T,HANDLER>(inRHS); }
operator Dynamic() const
{
hx::Object *result = 0;
HANDLER::handler(dhoToDynamic, (void *)&value, sizeof(T), &result );
if (result)
return result;
return CreateDynamicStruct( &value, sizeof(T), HANDLER::handler);
}
operator String() const { return HANDLER::toString(&value); }
inline Struct( const hx::Val &inRHS) { fromDynamic(inRHS.asObject()); }
operator hx::Val() const { return operator Dynamic(); }
bool operator==(const Struct<T,HANDLER> &inRHS) const { return value==inRHS.value; }
bool operator==(const null &inRHS) const { return false; }
bool operator!=(const null &inRHS) const { return true; }
// Haxe uses -> notation
inline T *operator->() { return &value; }
T &get() { return value; }
static inline bool is( const Dynamic &inRHS)
{
hx::Object *ptr = inRHS.mPtr;
if (!ptr)
return false;
StructHandlerDynamicParams convert(ptr, ptr->__CStr());
HANDLER::handler(dhoIs, 0, sizeof(T), &convert );
return convert.outProcessed;
}
inline void fromDynamic( hx::Object *ptr)
{
if (!ptr)
{
value = T();
return;
}
StructHandlerDynamicParams convert(ptr, ptr->__CStr());
HANDLER::handler(dhoFromDynamic, &value, sizeof(T), &convert );
if (!convert.outProcessed)
{
hx::NullReference("DynamicData", true);
return;
}
}
inline operator T& () { return value; }
};
template<typename T>
class Pointer
{
public:
typedef T elementType;
T *ptr;
inline Pointer( ) : ptr(0) { }
inline Pointer( const Pointer &inRHS ) : ptr(inRHS.ptr) { }
inline Pointer( const Dynamic &inRHS) { ptr = inRHS==null()?0: (T*)inRHS->__GetHandle(); }
inline Pointer( const null &inRHS ) : ptr(0) { }
inline Pointer( const cpp::Variant &inVariant ) {
hx::Object *obj = inVariant.asObject();
ptr = obj ? (T*)inVariant.valObject->__GetHandle() : 0;
}
template<typename O>
inline Pointer( const O *inValue ) : ptr( (T*) inValue) { }
//inline Pointer( T *inValue ) : ptr(inValue) { }
inline Pointer( AutoCast inValue ) : ptr( (T*)inValue.value) { }
template<typename H>
inline Pointer( const Struct<T,H> &structVal ) : ptr( &structVal.value ) { }
template<typename O>
inline void setRaw(const O *inValue ) { ptr = (T*) inValue; }
inline Pointer operator=( const Pointer &inRHS ) { return ptr = inRHS.ptr; }
inline Dynamic operator=( Dynamic &inValue )
{
ptr = inValue==null() ? 0 : (T*) inValue->__GetHandle();
return inValue;
}
inline Dynamic operator=( null &inValue ) { ptr=0; return inValue; }
template<typename O>
inline Pointer operator=( const Pointer<O> &inValue ) { ptr = (T*) inValue.ptr; return *this; }
template<typename O>
inline Pointer operator=( const O *inValue ) { ptr = (T*) inValue; return *this; }
template<typename H>
inline Pointer operator=( const Struct<T,H> &structVal ) { ptr = &structVal.value; return *this; }
inline AutoCast reinterpret() { return AutoCast(ptr); }
inline RawAutoCast rawCast() { return RawAutoCast(ptr); }
inline bool operator==( const null &inValue ) const { return ptr==0; }
inline bool operator!=( const null &inValue ) const { return ptr!=0; }
// Allow '->' syntax
inline Pointer *operator->() { return this; }
inline Pointer inc() { return ++ptr; }
inline Pointer dec() { return --ptr; }
inline Pointer add(int inInt) { return ptr+inInt; }
inline Pointer sub(int inInt) { return ptr-inInt; }
inline Pointer incBy(int inDiff) { ptr+=inDiff; return ptr; }
inline Pointer decBy(int inDiff) { ptr-=inDiff; return ptr; }
inline T &postIncRef() { return *ptr++; }
inline T &postIncVal() { return *ptr++; }
inline T &at(int inIndex) { return ptr[inIndex]; }
inline void setAt(int inIndex, const T &test) { ptr[inIndex] = test; }
inline T &__get(int inIndex) { return ptr[inIndex]; }
inline T &__set(int inIndex, const T &inValue) { T *p = ptr+inIndex; *p = inValue; return *p; }
inline T &get_value() { return *ptr; }
inline T &get_ref() { return *ptr; }
inline T &set_ref(const T &inValue) { return *ptr = inValue; }
operator Dynamic () const { return CreateDynamicPointer((void *)ptr); }
operator cpp::Variant () const { return CreateDynamicPointer((void *)ptr); }
operator T * () { return ptr; }
T * get_raw() { return ptr; }
const T * get_constRaw() { return ptr; }
inline void destroy() { delete ptr; }
inline void destroyArray() { delete [] ptr; }
inline bool lt(Pointer inOther) { return ptr < inOther.ptr; }
inline bool gt(Pointer inOther) { return ptr > inOther.ptr; }
inline bool leq(Pointer inOther) { return ptr <= inOther.ptr; }
inline bool geq(Pointer inOther) { return ptr >= inOther.ptr; }
};
template<>
class Pointer<void>
{
public:
enum { elementSize = 0 };
void *ptr;
inline Pointer( ) : ptr(0) { }
inline Pointer( const Pointer &inRHS ) : ptr(inRHS.ptr) { }
inline Pointer( const Dynamic &inRHS) { ptr = inRHS==null()?0: (void*)inRHS->__GetHandle(); }
inline Pointer( const null &inRHS ) : ptr(0) { }
template<typename O>
inline Pointer( const O *inValue ) : ptr( (void*) inValue) { }
//inline Pointer( T *inValue ) : ptr(inValue) { }
inline Pointer( AutoCast inValue ) : ptr( (void*)inValue.value) { }
inline Pointer operator=( const Pointer &inRHS ) { return ptr = inRHS.ptr; }
inline Dynamic operator=( Dynamic &inValue )
{
ptr = inValue==null() ? 0 : (void*) inValue->__GetHandle();
return inValue;
}
inline Dynamic operator=( null &inValue ) { ptr=0; return inValue; }
inline AutoCast reinterpret() { return AutoCast(ptr); }
inline RawAutoCast rawCast() { return RawAutoCast(ptr); }
inline bool operator==( const null &inValue ) const { return ptr==0; }
inline bool operator!=( const null &inValue ) const { return ptr!=0; }
// Allow '->' syntax
inline Pointer *operator->() { return this; }
inline Pointer inc() { return ptr; }
inline Pointer dec() { return ptr; }
inline Pointer add(int inInt) { return ptr; }
inline Pointer sub(int inInt) { return ptr; }
inline Pointer incBy(int inDiff) { return ptr; }
inline Pointer decBy(int inDiff) { return ptr; }
inline void postIncRef() { }
inline void postIncVal() { }
inline void at(int inIndex) { }
inline void __get(int inIndex) { }
template<typename O>
inline void __set(int inIndex, O inValue) { }
inline void get_value() { }
inline void get_ref() { }
template<typename O> inline void set_ref(O val) { }
operator Dynamic () const { return CreateDynamicPointer(ptr); }
//operator hx::Val () const { return CreateDynamicPointer((void *)ptr); }
operator void * () { return ptr; }
void * get_raw() { return ptr; }
const void * get_constRaw() { return ptr; }
inline void destroy() { }
inline void destroyArray() { }
inline bool lt(Pointer inOther) { return ptr < inOther.ptr; }
inline bool gt(Pointer inOther) { return ptr > inOther.ptr; }
inline bool leq(Pointer inOther) { return ptr <= inOther.ptr; }
inline bool geq(Pointer inOther) { return ptr >= inOther.ptr; }
};
template<typename T>
inline bool operator == (const null &, Pointer<T> inPtr) { return inPtr.ptr==0; }
template<typename T>
inline bool operator != (const null &, Pointer<T> inPtr) { return inPtr.ptr!=0; }
template<typename T>
class Reference : public Pointer<T>
{
public:
using Pointer<T>::ptr;
inline Reference( const T &inRHS ) : Pointer<T>(&inRHS) { }
inline Reference( T &inRHS ) : Pointer<T>(&inRHS) { }
inline Reference( ) : Pointer<T>((T*)0) { }
inline Reference( const Reference &inRHS ) : Pointer<T>(inRHS.ptr) { }
inline Reference( const Dynamic &inRHS) { ptr = inRHS==null()?0: (T*)inRHS->__GetHandle(); }
inline Reference( const null &inRHS ) : Pointer<T>((T*)0) { }
inline Reference( const T *inValue ) : Pointer<T>( (T*) inValue) { }
//inline Reference( T *inValue ) : Pointer(inValue) { }
inline Reference( AutoCast inValue ) : Pointer<T>( (T*)inValue.value) { }
template<typename OTHER>
inline Reference( const Reference<OTHER> &inOther )
{
// Allow reinterpret or not?
ptr = (T*)inOther.ptr;
}
template<typename H>
inline Reference( const Struct<T,H> &structVal ) : Pointer<T>( &structVal.value ) { }
inline Reference operator=( const Reference &inRHS ) { return ptr = inRHS.ptr; }
inline T *operator->() const { return ptr; }
inline operator T &() { return *ptr; }
};
template<typename T,typename H>
Struct<T,H>::Struct( const Reference<T> &ref ) : value(*ref.ptr) { };
template<typename T>
class Function
{
public:
T *call;
inline Function( ) { }
inline Function( const Function &inRHS ) : call(inRHS.call) { }
inline Function( const Dynamic &inRHS) { call = inRHS==null()?0: (T*)inRHS->__GetHandle(); }
inline Function( const null &inRHS ) { call = 0; }
inline Function( T *inValue ) : call((T*)(inValue)) { }
//inline Function( T *inValue ) : call(inValue) { }
inline Function( AutoCast inValue ) : call( (T*)inValue.value) { }
inline Function( const hx::AnyCast &inValue ) : call( (T*)inValue.mPtr) { }
template<typename FROM>
inline static Function __new(FROM from)
{
return Function(from);
}
inline Function operator=( const Function &inRHS ) { return call = inRHS.call; }
inline Dynamic operator=( Dynamic &inValue )
{
call = inValue==null() ? 0 : (T*) inValue->__GetHandle();
return inValue;
}
inline Dynamic operator=( null &inValue ) { call=0; return inValue; }
inline bool operator==( const null &inValue ) const { return call==0; }
inline bool operator!=( const null &inValue ) const { return call!=0; }
operator Dynamic () const { return CreateDynamicPointer((void *)call); }
//operator hx::Val () const { return CreateDynamicPointer((void *)call); }
operator T * () { return call; }
operator void * () { return (void *)call; }
inline T &get_call() { return *call; }
inline bool lt(Function inOther) { return call < inOther.call; }
inline bool gt(Function inOther) { return call > inOther.call; }
inline bool leq(Function inOther) { return call <= inOther.call; }
inline bool geq(Function inOther) { return call >= inOther.call; }
};
template<typename T>
inline bool operator == (const null &, Function<T> inPtr) { return inPtr.call==0; }
template<typename T>
inline bool operator != (const null &, Function<T> inPtr) { return inPtr.call!=0; }
class Function_obj
{
public:
inline static AutoCast getProcAddress(String inLib, String inPrim)
{
return AutoCast(__hxcpp_get_proc_address(inLib, inPrim,false));
}
template<typename T>
inline static AutoCast fromStaticFunction(T *inFunction)
{
return AutoCast(inFunction);
}
};
class Pointer_obj
{
public:
template<typename T>
inline static AutoCast arrayElem(::Array<T> array, int inIndex) { return AutoCast(&array[inIndex]); }
inline static AutoCast arrayElem(Dynamic inVal, int inIndex)
{
if (inVal==null() || !inVal->__IsArray())
return AutoCast(0);
hx::ArrayBase *base = (hx::ArrayBase *)inVal.GetPtr();
return AutoCast(base->GetBase() + inIndex*base->GetElementSize());
}
template<typename T>
inline static AutoCast ofArray(::Array<T> array) { return AutoCast(&array[0]); }
inline static AutoCast ofArray(Dynamic inVal)
{
if (inVal==null() || !inVal->__IsArray())
return AutoCast(0);
hx::ArrayBase *base = (hx::ArrayBase *)inVal.GetPtr();
return AutoCast(base->GetBase());
}
template<typename T>
inline static Pointer<T> addressOf(T &value) { return Pointer<T>(&value); }
template<typename T>
inline static Pointer<void> endOf(hx::ObjectPtr<T> value) { return (void *)(value.mPtr+1); }
template<typename T>
inline static Pointer<T> fromPointer(T *value) { return Pointer<T>(value); }
template<typename T>
inline static Pointer<T> fromPointer(const T *value) { return Pointer<T>(value); }
template<typename T>
inline static Pointer<T> fromRaw(T *value) { return Pointer<T>(value); }
template<typename T>
inline static Pointer<T> fromRaw(const T *value) { return Pointer<T>(value); }
inline static Pointer<void> fromRaw(const AutoCast &inAutoCast) { return Pointer<void>(inAutoCast.value); }
inline static Pointer<void> fromRaw(const RawAutoCast &inAutoCast) { return Pointer<void>(inAutoCast.value); }
inline static AutoCast fromHandle(Dynamic inValue, String inKind)
{
if (inValue==null() || (inKind!=null() && inKind!=__hxcpp_get_kind(inValue)))
return AutoCast(0);
return AutoCast(inValue->__GetHandle());
}
};
class Reference_obj
{
public:
};
} // end namespace cpp
namespace hx
{
template <typename T>
T *StarOf(T &x) { return &x; }
}
#endif